package io.renren.socket;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufUtil;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.renren.common.utils.StringUtils;
import io.renren.modules.substation.controller.TInfoBackupConfigController;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.math.BigInteger;

public class PackageSpliter extends LengthFieldBasedFrameDecoder {
    private static Logger logger = LoggerFactory.getLogger(TInfoBackupConfigController.class);

    private ByteBuf header;
    private ByteBuf ender;

    public PackageSpliter(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength) {
        super(maxFrameLength, lengthFieldOffset, lengthFieldLength);

        logger.debug("-------------------PackageSpliter header----------------");
        byte[] head=new byte[]{(byte)0xFF,(byte)0xFF,(byte)0xFF,(byte)0xFF} ;//
//        byte[] tail=new byte[]{ 88,88} ;// 十六进制是 [0x58,0x58]
        this.header = Unpooled.copiedBuffer(head);
//        this.ender = Unpooled.copiedBuffer(tail);

    }

    @Override
    protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception {

//        ByteBuf inhead = decodeHead(in);
        if(in != null) {
            if(header != null){
                int index = ByteBufUtil.indexOf(header, in);
                // 帧头第一次出现位置找到
                if (index > -1 && index < in.capacity()) {
                    //logger.debug("舍弃帧头前面的数据");
                    // 舍弃帧头前面的数据
                    in.readerIndex(index);
//                    if(index > 0) {
//                        logger.debug("清理数据");
//                        in.readBytes(index);
//                        in.discardReadBytes();
//                    }
                }
            }

            byte[] bytes = new byte[in.readableBytes()];
            in.getBytes(in.readerIndex(), bytes);
            String hexStr = StringUtils.bytesToHexString(bytes);
//            logger.debug("PackageSpliter decode:" + hexStr);
//        logger.debug("in.readableBytes:" + in.readableBytes() + " bytes.length:"+bytes.length);
//
//        if(bytes.length > 0) {
//            byte readbyte;
//            if(!hexStr.substring(0,2).equals("FF")) {
//                readbyte = in.readByte();
//                in.discardReadBytes();
//            }
//
//            if(bytes.length > 1 && !hexStr.substring(2,4).equals("FF")) {
//
//            }
//        }
//        if(bytes.length > 3) {
//            logger.debug("bytes[0]:" + bytes[0] + "bytes[3]" + bytes[3] );
//            if(!hexStr.substring(0,8).equals("FFFFFFFF")) {
//                byte readbyte = in.readByte();
//                String readByteStr = String.format("%02X", readbyte);
//                for(int i=0;(!readByteStr.equals("FF") || );i++)
//                {
//                    in.discardReadBytes();
//                    readbyte = in.readByte();
//                    readByteStr = String.format("%02X", readbyte);
//
//                    logger.debug("清理接收错误缓存区" + hexStr + " readByteStr:"+readByteStr);
//                }
//
//            } else
            if (bytes.length > 4) {
//                int interstr1 = Integer.parseInt(hexStr.substring(8,10), 16);
//                logger.debug("interstr1:" + interstr1);
//                if(interstr1 > 0x7F) {
//                    in.readBytes(in.readableBytes());
//                    in.discardReadBytes();
//                    logger.debug("长度超出限制，清理接收错误缓存区" + hexStr);
//                }

//                if(!hexStr.substring(0,8).equals("FFFFFFFF")) {
//                    byte[] readbyte = in.readBytes(bytes.length);
//                    in.discardReadBytes();
//                }
            }
//        }
        }
        return super.decode(ctx, in);

    }
//    public PackageSpliter() {
//        super(Integer.MAX_VALUE, 4,4);
//        super(10240, 4,4);
//    }

    /***
      * 利用帧头和帧尾取出数据帧，过滤帧头前无效数据，过滤没有帧头和帧尾的数据。
      * @param  buf:字节缓冲区
      * @return ByteBuf:数据帧（去掉帧头和帧尾）
      * 
      * 
      *  */
    protected ByteBuf decodeHead(ByteBuf buf) {
        logger.debug("decodeHead decode 1 ");
        // 帧头起始位置
        int sliceStart = 0;
//        // 帧尾起始位置
//        int sliceEnd = 0;
        // 数据帧
        ByteBuf frame = null;
        // 帧头是存在
        if (header != null) {
            logger.debug("decodeHead decode 2 ");
            // 获取帧头位置
            int index = ByteBufUtil.indexOf(header, buf);
            // 帧头第一次出现位置找到
            if (index > -1 && index < buf.capacity()) {
                logger.debug("decodeHead decode 3 ");
                // 舍弃帧头前面的数据
                buf.readerIndex(index);
                logger.debug("decodeHead decode 4 ");
                // 将帧头位置保存
                sliceStart = index;
                logger.debug("decodeHead decode 5 ");
                byte[] bytes = new byte[8];
                buf.getBytes(buf.readerIndex(),bytes);
                String hexStr = StringUtils.bytesToHexString(bytes);
//                logger.debug("decodeHead - hexStr:" + hexStr);
                String hexLen = hexStr.substring(8,16);
                //解析长度
                BigInteger hexLen2 = new BigInteger(hexLen, 16);
                hexLen2 = hexLen2.multiply(new BigInteger("2"));
                int datalen = hexStr.substring(16).length();
                //计算长度
                BigInteger datalen2 = new BigInteger(String.valueOf(datalen));

                // 获取数据子帧
                frame = buf.slice(sliceStart, buf.readableBytes());
                // 将reader索引设定到帧尾的后面
                buf.skipBytes(datalen);
                // 将数据帧返回
                logger.debug("decodeHead decode 6 ");
                return frame;
            }
        }
        return null;
    }
    
//    /***
//      * 利用帧头和帧尾取出数据帧，过滤帧头前无效数据，过滤没有帧头和帧尾的数据。
//      * @param  buf:字节缓冲区
//      * @return ByteBuf:数据帧（去掉帧头和帧尾）
//      * 
//      * 
//      *  */
//    protected ByteBuf decodeHead(ByteBuf buf) {
//        // 帧头起始位置
//        int sliceStart = 0;
//        // 帧尾起始位置
//        int sliceEnd = 0;
//        // 数据帧
//        ByteBuf frame = null;
//        // 帧头是存在
//        if (header != null) {
//            // 获取帧头位置
//            int index = ByteBufUtil.indexOf(header, buf);
//            // 帧头第一次出现位置找到
//            if (index > -1 && index < buf.capacity()) {
//                // 舍弃帧头前面的数据
//                buf.readerIndex(index);
//                // 将帧头位置保存
//                sliceStart = index;
//            }
//        }
//        // 帧尾存在
//        if (ender != null) {
//            // 获取帧尾的起始位置
//            int endindex = ByteBufUtil.indexOf(ender, buf);
//            // 帧尾找到，并且在帧头的后面
//            if (endindex > -1 && endindex > sliceStart && endindex < buf.capacity()) {
//                // 保存帧尾的位置
//                sliceEnd = endindex;
//                // 计算数据帧的长度：帧尾的起始位置-帧头的起始位置-帧头的长度
//                int length = sliceEnd - sliceStart - header.readableBytes();
//                // 获取数据子帧
//                frame = buf.slice(sliceStart + header.readableBytes(), length);
//                // 将reader索引设定到帧尾的后面
//                buf.skipBytes(sliceEnd - sliceStart + ender.readableBytes());
//                // 将数据帧返回
//                return frame;
//            }
//        }
//        //去掉剩余的垃圾数据
//        if(sliceEnd==-1 && sliceEnd==-1)
//        {
//            //将可读数据设置为0
//             buf.skipBytes(buf.readableBytes());
//        }
//        return null;
//    }
}
